package com.nf.mvc.util;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class ClassUtils {

    public static boolean isSimpleType(Class<?> type) {
        return isPrimitiveOrWrapper(type)
                || LocalDate.class == type
                || LocalDateTime.class == type
                || LocalTime.class == type
                || CharSequence.class.isAssignableFrom(type);
    }

    /**
     * 用来判断clazz是否是一个包装类型
     *
     * @param clazz
     * @return
     */
    public static boolean isPrimitiveWrapper(Class<?> clazz) {
        if (Boolean.class == clazz
                || Byte.class == clazz
                || Character.class == clazz
                || Double.class == clazz
                || Float.class == clazz
                || Integer.class == clazz
                || Long.class == clazz
                || Short.class == clazz) {
            return true;
        }
        return false;
    }

    /**
     * 判断一个类型是否是简单类型以及包装类型
     *
     * @return
     */
    public static boolean isPrimitiveOrWrapper(Class<?> clz) {
        return clz.isPrimitive() || isPrimitiveWrapper(clz);
    }


    /**
     * pojo类的标准（我自己定义的）
     * <ul>
     *     <li>除了Serializable接口，不实现任何其它接口</li>
     *     <li>没有父类，除了默认的Object</li>
     *     <li>内部的字段都是简单类型</li>
     * </ul>
     *
     * @param clz
     * @return
     */
    public static boolean isPojo(Class<?> clz) {
        Class<?>[] interfaces = clz.getInterfaces();
        if (interfaces.length > 1) return false;

        if (interfaces.length == 1 && !Serializable.class.isAssignableFrom(clz)) return false;

        if (clz.getSuperclass() != Object.class) return false;

        Field[] fields = clz.getDeclaredFields();

        for (Field field : fields) {
            if (!isSimpleType(field.getType())) {
                return false;
            }
        }

        return true;
    }
}
